Reactivity of Cooperative Systems: Application to ReactiveML -- extended version

Cooperative scheduling enables efficient sequential implementations of concurrency. It is widely used to provide lightweight threads facilities as libraries or programming constructs in many programming languages. However, it is up to programmers to actually cooperate to ensure the reactivity of their programs. We present a static analysis that checks the reactivity of programs by abstracting them into so-called behaviors using a type-and-effect system. Our objective is to find a good compromise between the complexity of the analysis and its precision for typical reactive programs. The simplicity of the analysis is mandatory for the programmer to be able to understand error messages and how to fix reactivity problems. Our work is applied and implemented in the functional synchronous language ReactiveML. It handles recursion, higher-order processes and first-class signals. We prove the soundness of our analysis with respect to the big-step semantics of the language: a well-typed program with reactive effects is reactive. The analysis is easy to implement and generic enough to be applicable to other models of concurrency such as coroutines. This research report is the extended version of the article published at the 21st International Static Analysis Symposium.L'ordonnancement coopératif permet l'implémentation séquentielle efficace de la concurrence. Il est largement utilisé pour fournir des threads légers sous forme de bibliothèques ou de constructions de programmation dans de nombreux langages de programmation. Toutefois, il appartient aux programmeurs d'appeler des primitives de coopération pour assurer la réactivité de leurs programmes. Nous présentons une analyse statique qui vérifie la réactivité des programmes en les abstrayant en comportements à l'aide d'un système de types à effets. Notre objectif est de trouver un bon compromis entre la complexité de l'analyse et sa précision pour les programmes réactifs typiques. La simplicité de l'analyse est obligatoire pour que le programmeur soit en mesure de comprendre les messages d'erreur et comment résoudre les problèmes de réactivité. Notre travail est appliqué et mis en oeuvre dans le langage synchrone fonctionnel ReactiveML. Il gère la récursivité, les processus d'ordre supérieur et les signaux de première classe. Nous prouvons la correction de notre analyse par rapport à la sémantique grands pas du langage~: un programme bien typé avec des effets réactifs est réactif. L'analyse est facile à mettre en oeuvre et assez générique pour être applicable à d'autres modèles de concurrence, tels que les coroutines. Ce rapport de recherche est la version étendue de l'article publié dans les actes de la 21ème édition de l'International Static Analysis Symposium

Réactivité des systèmes coopératifs : le cas de ReactiveML

International audienceLa concurrence coopérative est un modèle de programmation très répandu. On peut par exemple l'utiliser en OCaml à travers des bibliothèques comme Lwt, Async ou Equeue. Il a de nombreux avantages tels que l'absence de courses critiques et des implantations légères et efficaces. Néanmoins, un des inconvénients majeurs de ce modèle est qu'il dépend de la discipline du programmeur pour garantir que le système est réactif : un processus peut empêcher les autres de s'exécuter. ReactiveML est un langage qui étend OCaml avec des constructions de concurrence coopérative. Il propose une analyse statique, l'analyse de réactivité, qui permet de détecter les expressions qui risquent de produire des comportements non coopératifs. Dans cet article, nous présentons cette analyse statique qui se définit à l'aide d'un système de types et effets. Ainsi, comme le typage de données aide les programmeurs à détecter des erreurs d'exécution au plus tôt, l'analyse de réactivité aide à détecter des erreurs de concurrence

Exécution efficace de programmes ReactiveML

National audienceReactiveML est un langage dédié à la programmation de systèmes combinant des parties algorithmiques et réactives. Il s'agit d'une extension de ML avec des constructions pour la concurrence inspirées des langages synchrones. Celles-ci permettent d'obtenir une très grande expressivité, mais leur implantation efficace représente un défi. Dans cet article, nous présentons l'implantation de ReactiveML, de la compilation à l'implantation du moteur d'exécution en OCaml. Nous décrivons également une implantation parallèle en mémoire partagée du moteur d'exécution utilisant le vol de tâches. L'approche choisie permet d'obtenir une exécution efficace même en présence de structures de contrôle complexes. Elle s'étend simplement au cas parallèle avec des résultats expérimentaux prometteurs

Scade 6: from a Kahn Semantics to a Kahn Implementation for Multicore

International audienceSCADE is an environment for developing critical embedded software that is used for more than twenty years in various application domains like avionics, nuclear plants, transportation, automotive. It comes with a language and a code generator which complies with the highest safety standards like DO-178C, IEC 61508, EN 50128, IEC 60880 and ISO 26262. The language has been founded on the pioneering work by Caspi and Halbwachs on Lustre. In 2008, a major revision of the language and compiler, named 'Scade 6', was released. One of its novelty was a smooth integration of the traditional data-flow style of Lustre with control-structures inspired from those of Esterel and SyncCharts, with static/dynamic semantics and a compilation inspired from Lucid Synchrone. In particular, it relies on four dedicated type systems-typing, clock calculus, causality analysis, initialization analysis-and a compilation through source-to-source transformations into a minimal clocked data-flow language, based on a Kahn semantics, that is translated to imperative code. One ongoing work is the generation of code for multi-core architectures. Because of the intrinsic deterministic parallelism of Scade, we propose a solution that relies on annotations that specify what must be executed concurrently but do not change the semantics. The paper is a survey of past to ongoing work on Scade 6 language definition and implementation

A Synchronous Look at the Simulink Standard Library

International audienceHybrid systems modelers like Simulink come with a rich collection of discrete-time and continuous-time blocks. Most blocks are not defined in terms of more elementary ones—and some cannot be—but are instead written in imperative code and explained informally in a reference manual. This raises the question of defining a minimal set of orthogonal programming constructs such that most blocks can be programmed directly and thereby given a specification that is mathematically precise, and whose compiled version performs comparably to handwritten code. In this paper, we show that a fairly large set of blocks of a standard library like the one provided by Simulink can be programmed in a precise, purely functional language using stream equations, hierarchical automata, Ordinary Differential Equations (ODEs), and deterministic synchronous parallel composition. Some blocks cannot be expressed in our setting as they mix discrete-time and continuous-time signals in unprincipled ways that are statically forbidden by the type checker. The experiment is conducted in Zélus, a synchronous language that conservatively extends Lustre with ODEs to program systems that mix discrete-time and continuous-time signals